﻿using System;
using Microsoft.VisualBasic;
using System.Web.UI;
using System.Web.UI.HtmlControls;

[PersistChildren(true)]
public class Page : System.Web.UI.Page, INamingContainer {
    
#region variaveis
    private System.Web.UI.ScriptManager scrManager;
    private string strClasseCarga;
    private bool bolCarregarControles;
    private bool bolGravarControles;
    private string strPropriedadeChave = "ID";
    private string strPropriedadeErro = "ERRO";
    private string strQueryStringChave = "id";
    private string strMetodoCarga = "Carregar";
    private string strMetodoIncluir = "Incluir";
    private string strMetodoAtualizar = "Atualizar";
    private string strMetodoExcluir = "Excluir";
    private string strMetodoLimpar = "Limpar";
    private object objValorChave;
    private object ObjetoBase;
    private ArrayList arrObjetoBaseDataSource;
    private bool bolLimpar;
    private bool bolEdicao;
    private bool bolInsercao;
    private Erro eErro = new Erro(Erro.Tipo.SemErro);
    private Erro eErroCarga = new Erro(Erro.Tipo.SemErro);
#endregion

#region Propriedades

    public object ObjetoBaseNegocio {
        get {
            return this.ObjetoBase;
        }
        set {
            this.ObjetoBase = value;
        }
    }
    
    public bool CarregarControles {
        get {
            return bolCarregarControles;
        }
    }
    
    public bool GravarControles {
        get {
            return bolGravarControles;
        }
        set {
            bolGravarControles = value;
        }
    }
    
    public string ClasseCarga {
        get {
            return this.strClasseCarga;
        }
    }
    
    public string MetodoCarga {
        get {
            return strMetodoCarga;
        }
        set {
            strMetodoCarga = value;
        }
    }
    
    public string MetodoIncluir {
        get {
            return this.strMetodoIncluir;
        }
        set {
            this.strMetodoIncluir = value;
        }
    }
    
    public string MetodoAlterar {
        get {
            return this.strMetodoAtualizar;
        }
        set {
            this.strMetodoAtualizar = value;
        }
    }
    
    public string MetodoExcluir {
        get {
            return this.strMetodoExcluir;
        }
        set {
            this.strMetodoExcluir = value;
        }
    }
    
    public string MetodoLimpar {
        get {
            return this.strMetodoLimpar;
        }
        set {
            this.strMetodoLimpar = value;
        }
    }
    
    public object ValorChave {
        get {
            return this.objValorChave;
        }
        set {
            this.objValorChave = value;
        }
    }
    
    public string PropriedadeChave {
        get {
            return strPropriedadeChave;
        }
        set {
            strPropriedadeChave = value;
        }
    }
    
    public string QueryStringChave {
        get {
            return strQueryStringChave;
        }
        set {
            strQueryStringChave = value;
        }
    }
    
    public string PropriedadeErro {
        get {
            return strPropriedadeErro;
        }
        set {
            strPropriedadeErro = value;
        }
    }
    
    public bool Insercao {
        get {
            return bolInsercao;
        }
    }
    
    public bool Edicao {
        get {
            return bolEdicao;
        }
    }
    
    public bool LimparControles {
        get {
            return this.bolLimpar;
        }
    }
    
    public System.Web.UI.ScriptManager ScriptManager {
        get {
            return this.scrManager;
        }
        set {
            this.scrManager = value;
        }
    }
    
    public Erro ERRO {
        get {
            if ((this.eErro == null)) {
                return new Erro(Erro.Tipo.SemErro);
            }
            else {
                return this.eErro;
            }
        }
    }
    
    public Erro ERRO_CARGA {
        get {
            if ((this.eErroCarga == null)) {
                return new Erro(Erro.Tipo.SemErro);
            }
            else {
                return this.eErroCarga;
            }
        }
    }
#endregion

#region Eventos
    public event EventHandler InicioEdicao;
    
    public event EventHandler ConclusaoEdicao;
    
    public event EventHandler AposCancelar;
    
    public event EventHandler AntesGravar;
    
    public event EventHandler AposGravar;
    
    public event EventHandler AposCarregar;
    
    public event EventHandler AntesExcluir;
    
    public event EventHandler AposExcluir;
    
    public event EventHandler AposLimpar;
    
    public event EventHandler AposAtualizar;
    
    public event EventHandler AposIncluir;
#endregion

   
   public object CarregarObjetoBase(object ObjBase, bool bitCarregarControles) {
        try 
        {
            this.strClasseCarga = ObjBase.GetType().FullName.Trim().ToUpper(System.Globalization.CultureInfo.CurrentCulture);
            this.bolCarregarControles = bitCarregarControles;
            this.ObjetoBase = ObjBase;
            if (((strPropriedadeChave != string.Empty) && (strQueryStringChave != string.Empty))) {
                if (!(this.Request.QueryString[strQueryStringChave] == null)) {
                    objValorChave = Request.QueryString[this.strQueryStringChave];
                    if (!(objValorChave == null)) {
                        System.Type typ;
                        typ = ObjBase.GetType().GetProperty(strPropriedadeChave).PropertyType;
                        if (ObjBase.GetType().GetProperty(strPropriedadeChave).CanWrite) {
                            ObjBase.GetType().GetProperty(strPropriedadeChave).SetValue(ObjBase, Convert.ChangeType(objValorChave, typ, System.Globalization.CultureInfo.CurrentCulture), null);
                        }
                    }
                }
                else {
                    return ObjBase;
                }
            }
            else {
                return ObjBase;
            }

            ObjBase.GetType().InvokeMember(strMetodoCarga, System.Reflection.BindingFlags.InvokeMethod, null, ObjBase, null, System.Globalization.CultureInfo.CurrentCulture);
            this.eErroCarga = (Erro)ObjBase.GetType().GetProperty(this.strPropriedadeErro).GetValue(this.ObjetoBase, null);
            this.eErro = eErroCarga;
            return ObjBase;
        }
        finally {
            AposCarregar();
        }
    }
    
    public object CarregarValorControle(string strPropriedadeCarga) {
        try {
            object obj = new object();
            obj = null;
            if ((strPropriedadeCarga.Trim() != string.Empty)) {
                if ((this.ObjetoBase.GetType().GetMember(strPropriedadeCarga)[0].MemberType == System.Reflection.MemberTypes.Property)) {
                    obj = this.ObjetoBase.GetType().GetProperty(strPropriedadeCarga).GetValue(this.ObjetoBase, null);
                }
                else {
                    obj = this.ObjetoBase.GetType().InvokeMember(strPropriedadeCarga, System.Reflection.BindingFlags.InvokeMethod, null, this.ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
                }
            }
            return obj;
        }
        catch {
            return null;
        }
    }
    
    public object ConsultarPropriedade(string strPropriedade) {
        try {
            object obj = new object();
            obj = null;
            if ((strPropriedade.Trim() != string.Empty)) {
                if ((this.ObjetoBase.GetType().GetMember(strPropriedade)[0].MemberType == System.Reflection.MemberTypes.Property)) {
                    obj = this.ObjetoBase.GetType().GetProperty(strPropriedade).GetValue(this.ObjetoBase, null);
                }
                else {
                    obj = this.ObjetoBase.GetType().InvokeMember(strPropriedade, System.Reflection.BindingFlags.InvokeMethod, null, this.ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
                }
            }
            return obj;
        }
        catch (Exception ex) {
            throw new Exception(("Erro ao carregar a propriedade:" + (strPropriedade + (" Mensagem:" + ex.Message))));
        }
    }
    
    public void AtualizarValorControle(string strPropriedadeCarga, object objetoValor) {
        if ((strPropriedadeCarga.Trim() != String.Empty)) {
            try {
                Type typ;
                typ = this.ObjetoBase.GetType().GetProperty(strPropriedadeCarga).PropertyType;
                if (ObjetoBase.GetType().GetProperty(strPropriedadeCarga).CanWrite) {
                    try {
                        ObjetoBase.GetType().GetProperty(strPropriedadeCarga).SetValue(ObjetoBase, Convert.ChangeType(objetoValor, typ, System.Globalization.CultureInfo.CurrentCulture), null);
                    }
                    catch  {
                        if (typ.ToString().Contains("*Date*")) {
    
                        ObjetoBase.GetType().GetProperty(strPropriedadeCarga).SetValue(ObjetoBase, null, null);
                        }
                    }
                }
            }
            catch (Exception ex)  {
                if (this.Edicao) {
                    throw new Exception(("Erro ao tentar atualizar a propriedade: " + (strPropriedadeCarga + (" Mensagem: " + ex.Message))));
                 }
            }
        }
    }
    
    public object InvocarMetodoObjetoBase(string strMetodo, object[] objetoArgumentos) {
        object objRetorno;
        System.Reflection.MethodInfo mi;
        System.Reflection.ParameterInfo[] pi;
        mi = ObjetoBase.GetType().GetMethod(strMetodo);
        pi = mi.GetParameters();
        foreach (System.Reflection.ParameterInfo p in pi) {
            if (p.ParameterType.IsEnum) {
                objetoArgumentos[Array.IndexOf(pi, p)] = System.Enum.Parse(p.ParameterType, objetoArgumentos[Array.IndexOf(pi, p)].ToString());
            }
            else if ((p.ParameterType.ToString() == "System.DateTime")) {
                if ((objetoArgumentos[Array.IndexOf(pi, p)].ToString().Trim() == string.Empty)) {
                    objetoArgumentos[Array.IndexOf(pi, p)] = null;
                }
                else {
                    objetoArgumentos[Array.IndexOf(pi, p)] = DateTime.Parse(objetoArgumentos[Array.IndexOf(pi, p)].ToString());
                }
            }
            else if ((p.ParameterType.ToString() == "System.Boolean")) {
                objetoArgumentos[Array.IndexOf(pi, p)] = bool.Parse(objetoArgumentos[Array.IndexOf(pi, p)].ToString());
            }
            else if (!p.ParameterType.HasElementType) {
                objetoArgumentos[Array.IndexOf(pi, p)] = Convert.ChangeType(objetoArgumentos[Array.IndexOf(pi, p)], p.ParameterType, System.Globalization.CultureInfo.CurrentCulture);
            }
        }
        objRetorno = ObjetoBase.GetType().InvokeMember(strMetodo, System.Reflection.BindingFlags.InvokeMethod, null, ObjetoBase, objetoArgumentos, System.Globalization.CultureInfo.CurrentCulture);
        this.eErro = (Erro)ObjetoBase.GetType().GetProperty(this.strPropriedadeErro).GetValue(this.ObjetoBase, null);
        return objRetorno;
    }
    
    public object Gravar() {
        string strEvento = "";
        AntesGravar();
        try {
            if (this.IsValid) {
                if ((this.Insercao && this.Edicao)) {
                    this.ObjetoBase.GetType().InvokeMember(this.strMetodoIncluir, System.Reflection.BindingFlags.InvokeMethod, null, ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
                    strEvento = "I";
                }
                else if (this.Edicao) {
                    this.ObjetoBase.GetType().InvokeMember(this.strMetodoAtualizar, System.Reflection.BindingFlags.InvokeMethod, null, ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
                    strEvento = "A";
                }
                this.eErro = (Erro)ObjetoBase.GetType().GetProperty(this.strPropriedadeErro).GetValue(this.ObjetoBase, null);
                if ((this.eErro.NUMERO == Erro.Tipo.SemErro)) {
                    if (!(this.strPropriedadeChave == null)) {
                        this.objValorChave = ObjetoBase.GetType().GetProperty(this.strPropriedadeChave).GetValue(this.ObjetoBase, null);
                    }
                    this.CarregarObjetoBase(this.ObjetoBase, true);
                    this.bolCarregarControles = true;
                    this.bolInsercao = false;
                    this.bolEdicao = false;
                }
                return objValorChave;
            }
            else {
                this.eErro = new Erro(Erro.Tipo.ErroIndefinido, "Valores de campos inválidos!");
                return null;
            }
        }
        finally {
            AposGravar();
            if ((strEvento == "I")) {
                AposIncluir();
            }
            else if ((strEvento == "A")) {
                AposAtualizar();
            }
            ConclusaoEdicao();
        }
    }
    
    public void Novo() {
        if (!this.IsPostBack) {
            this.Limpar();
        }
        else {
            this.bolLimpar = false;
        }
        this.bolInsercao = true;
    }
    
    public void Limpar() {
        try {
            ObjetoBase.GetType().InvokeMember(strMetodoLimpar, System.Reflection.BindingFlags.InvokeMethod, null, ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
            this.objValorChave = null;
            this.bolCarregarControles = true;
            this.bolLimpar = true;
            this.eErro = (Erro)ObjetoBase.GetType().GetProperty(this.strPropriedadeErro).GetValue(this.ObjetoBase, null);
        }
        finally {
            AposLimpar();
        }
    }
    
    public void Excluir() {
        AntesExcluir();
        try {
            ObjetoBase.GetType().InvokeMember(strMetodoExcluir, System.Reflection.BindingFlags.InvokeMethod, null, ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
            this.eErro = (Erro)ObjetoBase.GetType().GetProperty(this.strPropriedadeErro).GetValue(this.ObjetoBase, null);
            if ((this.ERRO.NUMERO == Erro.Tipo.SemErro)) {
                Limpar();
            }
        }
        finally {
            AposExcluir();
        }
    }
    
    public void Editar() {
        this.bolEdicao = true;
        InicioEdicao();
    }
    
    public void CancelarEdicao() {
        this.bolEdicao = false;
        this.bolInsercao = false;
        AposCancelar();
        ConclusaoEdicao();
    }
    
    public void ReCarregarControles(bool bolRecarregarObjetoBase) {
        if (bolRecarregarObjetoBase){
            this.ObjetoBase.GetType().InvokeMember(strMetodoCarga, System.Reflection.BindingFlags.InvokeMethod, null, ObjetoBase, null, System.Globalization.CultureInfo.CurrentCulture);
           }
        this.bolCarregarControles = true;
    }
    
    private void Page_AposCancelar() {
    }
    
    private void Page_Init(object sender, System.EventArgs e) {
        if (!(this.Header == null)) {
            
        }
    }
    
    private void Page_InitComplete(object sender, System.EventArgs e) {
        this.ScriptManager = System.Web.UI.ScriptManager.GetCurrent(this.Page);
        }
    
    private void Page_PreInit(object sender, System.EventArgs e) {
        
    }
    
    private void Page_Unload(object sender, System.EventArgs e) {
        
    }
    
    public void AbrirPopup(
                string strURL, 
                string strQueryString, 
                string strNomeJanela, 
                int numLargura, 
                int numAltura, 
                bool bolRedimensionaTamanho, 
                bool bolExibeScroll, 
                bool bolEnviarPathAtual) {
        char[] str1;
        str1.SetValue("?",0);
        str1.SetValue("&",1);
        strQueryString = strQueryString.TrimStart(str1[0]);
        strQueryString = strQueryString.TrimStart(str1[1]);
        if ((strQueryString.Trim() != String.Empty)) {
            strQueryString = "&" + strQueryString;
        }
        string strScript;
        strScript = "<script>";
        strScript += "window.open(\'" + strURL + "?popup=1";

        if (bolEnviarPathAtual) {
            string strNomeDocumento;
            strNomeDocumento = this.Request.UrlReferrer.Segments[(this.Request.UrlReferrer.Segments.Length - 1)];
           strScript += "&path=" + Server.UrlEncode("./" + strNomeDocumento + this.Request.Url.Query);
        }
        strScript += strQueryString + "',";
        strScript += "'" + strNomeJanela + "',";
        strScript += "'top=20, left=20, width=" + numLargura + ",height=" + numAltura;
        if (bolRedimensionaTamanho) {
           strScript += ", resizable=1;";
        }
        if (bolExibeScroll) {
            strScript += ", scrollbars=1";
        }
        strScript += "');";
        strScript += "</script>";
        this.ClientScript.RegisterClientScriptBlock(this.GetType(), this.ClientID, strScript);
    }
    
    public void SetFocus(Web.UI.Control control) {
        if (!(this.scrManager == null)) {
            this.scrManager.SetFocus(control);
        }
        else {
            base.SetFocus(control);
        }
    }
    
    public void RegisterClientScriptBlock(string key, string script) {
        if (!(this.scrManager == null)) {
            this.scrManager.RegisterClientScriptBlock(this.Page, this.GetType(), key, script, false);
        }
        else {
            ClientScript.RegisterClientScriptBlock(this.GetType(), key, script);
        }
    }
    
    public void Alerta(string strMensagem) {
        strMensagem = strMensagem.Replace("\"", "");
        strMensagem = strMensagem.Replace("\'", "");
        strMensagem = strMensagem.Replace("\r\n", " ");
        string strScript;
        strScript = "<script language='javascript'>";
        strScript += " alert('" + (strMensagem + "')");
        strScript += "</script>";
        this.RegisterClientScriptBlock(("Alerta" + this.ClientID), strScript);
    }
    
    public void RedirecionarLocalidade(string strLocalidade, bool bolFinalizarRespostaPagina) {
        strLocalidade = strLocalidade.Replace("\"", "");
        strLocalidade = strLocalidade.Replace("\'", "");
        if (!bolFinalizarRespostaPagina) {
            string strScript;
            strScript = "<script language='javascript'>";
            strScript += " window.location='" + strLocalidade + "';";
            strScript += "</script>";
            this.RegisterClientScriptBlock(("Redirecionar" + this.ClientID), strScript);
        }
        else {
            this.Response.Redirect(strLocalidade, true);
        }
    }
    
    public void RedirecionarVoltar() {
        string strLocalidade;
        strLocalidade = this.Request.UrlReferrer.PathAndQuery;
        strLocalidade = strLocalidade.Replace("\"", "");
        strLocalidade = strLocalidade.Replace("\'", "");
        string strScript;
        strScript = "<script language='javascript'>";
        strScript += " if (confirm('Deseja voltar para a tela anterior?')) ";
        strScript += "{ window.location='" + strLocalidade + "'};";
        strScript += "</script>";
        this.RegisterClientScriptBlock(("Redirecionar" + this.ClientID), strScript);
    }
    
    ublic void FecharPopup(bool bolAtualizar, string strUrl) {
        string strScript;
        
        strScript = "<script>";
        strScript += "try{";
        if ((strUrl == String.Empty)) {
            strUrl = this.Request.QueryString["path"];
        }
        if (bolAtualizar) {
            strScript +="window.opener.document.location='" + Server.UrlDecode(strUrl) + "';");
        }
        strScript += "window.close();";
        strScript += "}catch(e){window.close()}";
        strScript += "</script>";
        this.RegisterClientScriptBlock("Fechar", strScript);
    }
    
    public void AtualizarJanelaOrigem() {
        string strScript;
        strScript = "<script>";
        strScript += "try{";
        strScript +="window.opener.document.location='" + Server.UrlDecode(this.Request.QueryString("path")) + "';");
        strScript += "}catch(e){null;}";
        strScript += "</script>";
        this.RegisterClientScriptBlock("AtualizarJanelaOrigem", strScript);
    }
    
    static bool IsPopup(Page page) {
        if (Information.IsNumeric(page.Request.QueryString["popup"])) {
            if ((page.Request.QueryString["popup"] == "1")) {
                return true;
            }
            else {
                return false;
            }
        }
        else {
            return false;
        }
    }
    
    public static Control FindControlRecursive(Control container, string id) {
        Control e = new Control();
        if (container.HasControls()) {
            foreach (Control ctrl in container.Controls) {
                e = FindControlRecursive(ctrl, id);
                if (!(e == null)) {
                    break;
                }
            }
        }
        else if ((container.ID == id)) {
            e = container;
        }
        else {
            e = null;
        }
        return e;
    }
}